import { Pages } from '@typings/pages'
import { TablePageCheck } from '@utils/table-util/TablePageCheck'
import { ElTable } from 'element-plus'

/**
 * 表格工具包
 */
export const TableUtil = {
  /**
   * 计算表格序号
   * @param pages
   * @param index
   * 用法：tableUtil.indexMethod.bind(this, pages)
   */
  indexMethod (pages: Pages, index: number): number {
    return pages.pageSize * (pages.pageNum - 1) + index + 1
  },

  /**
   * 过滤
   * @param key
   * @param value
   * @param row
   * 用法：tableUtil.filterTag.bind(this, key)
   */
  filterTag (key: string, value: string, row: Global.Object) {
    return row[key] === value
  },

  /**
   * 前端分页
   * @param tableData
   * @param pages
   */
  paging (tableData: any[], pages: Pages): any[] {
    // 如果无数据,直接返回
    if (tableData.length === 0) {
      pages.pageNum = 1
      return []
    }
    let start = pages.pageSize * (pages.pageNum - 1)
    let end = start + pages.pageSize
    // 如果页数大于数据,取最后一页
    if (tableData.length < start) {
      pages.pageNum = Math.ceil(tableData.length / pages.pageSize)
      start = pages.pageSize * pages.pageNum
      end = start + pages.pageSize
    }
    if (end > tableData.length) {
      end = tableData.length
    }
    const retData = []
    for (;start < end; start++) {
      retData.push(tableData[start])
    }
    return retData
  },

  /**
   * 高亮某一行
   * @param ref
   * @param index
   * @param timeout
   */
  highlightRow (ref: InstanceType<typeof ElTable>, index: number, timeout = 12000) {
    const trs = (ref.$el as HTMLDivElement).querySelectorAll('.el-table__body tbody tr') || []
    const row: HTMLTableRowElement = trs[index]
    if (row) {
      row.classList.add('el-c-highlight-row')
      setTimeout(() => {
        row.classList.remove('el-c-highlight-row')
      }, timeout)
    }
  },

  /**
   * 表格数据垂直化，原表格每行一个对象，改为每列一个对象
   * 函数用到了双重for循环和多个if，效率上可能比不上根据特定业务进行特定处理
   * 适用于已获取到原版水平的表格数据，需要垂直线上的方案
   */
  tableDataVertical (tableData: Record<string, any>[], options: {
    headerKey: string,
    headerTitle?: string,
    props?: Record<string, string>,
    keys?: string[],
    headerInBody?: boolean // tableData中会包含一份header信息，show-header="false"时可以使用
  }) {
    // 获取Keys 确认有几行
    const keys = options.keys || Object.keys(tableData[0])
    // 存储处理好的列数据，用于循环table-column
    const column = [
      { label: options.headerTitle, prop: 'head' }
    ]
    // 存储处理好的tableData数据
    const retData = {}
    // 循环tableData参数
    for (let i = 0, len = tableData.length; i < len; i++) {
      // 拿到当前对象
      const tableDateItem = tableData[i]
      // 循环keys，将对象中的各个属性分别存储到新的对象中
      for (let j = 0, len = keys.length; j < len; j++) {
        const key = keys[j]
        const value = tableDateItem[keys[j]]
        // 记录列信息
        if (key === options.headerKey) {
          column.push({ label: value, prop: 'col' + i })
        }
        if (options.headerInBody || key !== options.headerKey) {
          // eslint-disable-next-line no-prototype-builtins
          if (!retData.hasOwnProperty(key)) {
            // 初始化纵向头信息
            retData[key] = { head: options.props[key] || key }
          }
          retData[key]['col' + i] = value
        }
      }
    }
    return { column, tableData: Object.values(retData) }
  },
  TablePageCheck
}
